home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / compile_to_c21.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  28.9 KB  |  1,331 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "compile_to_c.h"
  10. void rT96add_last(T96 *C,T0 * a1){
  11. /*IF*/if (((C)->_capacity)<((rT96count(C))+(1))) {
  12. C->_capacity=((C)->_capacity)+(16);
  13. /*IF*/if (((C)->_capacity)==(16)) {
  14. C->_storage=malloc(16*sizeof(*(C->_storage)));
  15. }
  16. else {
  17. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  18. }
  19. /*FI*/}
  20. /*FI*/C->_upper=((C)->_upper)+(1);
  21. rT96put(C,a1,(C)->_upper);
  22. }
  23. int rT96equal_like(/*C*/T0 * a1,T0 * a2){
  24. int R=0;
  25. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  26. R=1;
  27. }
  28.  else if ((!(a1))||(!(a2))) {
  29. }
  30. else {
  31. R=rT94is_equal((T94*)a1,a2);
  32. }
  33. /*FI*/return R;
  34. }
  35. int rT96index_of(T96 *C,T0 * a1){
  36. int R=0;
  37. R=(C)->_lower;
  38. while (!(((R)>((C)->_upper))||(rT96equal_like(a1,rT96item(C,R))))) {
  39. R=(R)+(1);
  40. }
  41. return R;
  42. }
  43. void rT96put(T96 *C,T0 * a1,int a2){
  44. (C->_storage)[a2-(C->_lower)]=a1;
  45. }
  46. void rT96copy(T96 *C,T0* a1){
  47. int _i=0;
  48. C->_upper=((C)->_lower)-(1);
  49. /*IF*/if (((C)->_capacity)==(0)) {
  50. rT96make(C,((T96*)a1)->_lower,((T96*)a1)->_upper);
  51. }
  52. else {
  53. rT96resize(C,((T96*)a1)->_lower,((T96*)a1)->_upper);
  54. }
  55. /*FI*/_i=(C)->_lower;
  56. while (!((_i)>((C)->_upper))) {
  57. rT96put(C,rT96item((T96*)a1,_i),_i);
  58. _i=(_i)+(1);
  59. }
  60. }
  61. void rT96make(T96 *C,int a1,int a2){
  62. /*IF*/{/*AT*/free(C->_storage);
  63. }
  64. /*FI*/C->_lower=a1;
  65. C->_upper=a2;
  66. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  67. C->_storage=NULL;
  68. /*IF*/if (((C)->_capacity)>(0)) {
  69. C->_capacity=((C)->_capacity)+(16);
  70. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  71. rT96clear_all(C);
  72. }
  73. /*FI*/}
  74. void rT86clear_all(T86 *C){
  75. T0 * _value=NULL;
  76. rT86set_all_with(C,_value);
  77. }
  78. int rT86count(T86 *C){
  79. int R=0;
  80. R=(((C)->_upper)-((C)->_lower))+(1);
  81. return R;
  82. }
  83. void rT86set_all_with(T86 *C,T0 * a1){
  84. int _i=0;
  85. _i=(C)->_upper;
  86. while (!((_i)<((C)->_lower))) {
  87. rT86put(C,a1,_i);
  88. _i=(_i)-(1);
  89. }
  90. }
  91. void rT86resize(T86 *C,int a1,int a2){
  92. int _up=0;
  93. int _i=0;
  94. T0* _other=NULL;
  95. {T86 *n=((T86*)new(86));
  96. rT86make(n,a1,a2);
  97. _other=(T0 *)n;}
  98. _i=rT2max((C)->_lower,((T86*)_other)->_lower);
  99. _up=rT2min((C)->_upper,((T86*)_other)->_upper);
  100. while (!((_i)>(_up))) {
  101. rT86put((T86*)_other,rT86item(C,_i),_i);
  102. _i=(_i)+(1);
  103. }
  104. /*IF*/{/*AT*/free(C->_storage);
  105. }
  106. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  107. }
  108. T0 * rT86item(T86 *C,int a1){
  109. T0 * R=NULL;
  110. R=(C->_storage)[a1-(C->_lower)];
  111. return R;
  112. }
  113. void rT86add_last(T86 *C,T0 * a1){
  114. /*IF*/if (((C)->_capacity)<((rT86count(C))+(1))) {
  115. C->_capacity=((C)->_capacity)+(16);
  116. /*IF*/if (((C)->_capacity)==(16)) {
  117. C->_storage=malloc(16*sizeof(*(C->_storage)));
  118. }
  119. else {
  120. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  121. }
  122. /*FI*/}
  123. /*FI*/C->_upper=((C)->_upper)+(1);
  124. rT86put(C,a1,(C)->_upper);
  125. }
  126. void rT86put(T86 *C,T0 * a1,int a2){
  127. (C->_storage)[a2-(C->_lower)]=a1;
  128. }
  129. void rT86copy(T86 *C,T0* a1){
  130. int _i=0;
  131. C->_upper=((C)->_lower)-(1);
  132. /*IF*/if (((C)->_capacity)==(0)) {
  133. rT86make(C,((T86*)a1)->_lower,((T86*)a1)->_upper);
  134. }
  135. else {
  136. rT86resize(C,((T86*)a1)->_lower,((T86*)a1)->_upper);
  137. }
  138. /*FI*/_i=(C)->_lower;
  139. while (!((_i)>((C)->_upper))) {
  140. rT86put(C,rT86item((T86*)a1,_i),_i);
  141. _i=(_i)+(1);
  142. }
  143. }
  144. void rT86make(T86 *C,int a1,int a2){
  145. /*IF*/{/*AT*/free(C->_storage);
  146. }
  147. /*FI*/C->_lower=a1;
  148. C->_upper=a2;
  149. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  150. C->_storage=NULL;
  151. /*IF*/if (((C)->_capacity)>(0)) {
  152. C->_capacity=((C)->_capacity)+(16);
  153. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  154. rT86clear_all(C);
  155. }
  156. /*FI*/}
  157. void rT83clear_all(T83 *C){
  158. T0 * _value=NULL;
  159. rT83set_all_with(C,_value);
  160. }
  161. int rT83count(T83 *C){
  162. int R=0;
  163. R=(((C)->_upper)-((C)->_lower))+(1);
  164. return R;
  165. }
  166. void rT83set_all_with(T83 *C,T0 * a1){
  167. int _i=0;
  168. _i=(C)->_upper;
  169. while (!((_i)<((C)->_lower))) {
  170. rT83put(C,a1,_i);
  171. _i=(_i)-(1);
  172. }
  173. }
  174. void rT83resize(T83 *C,int a1,int a2){
  175. int _up=0;
  176. int _i=0;
  177. T0* _other=NULL;
  178. {T83 *n=((T83*)new(83));
  179. rT83make(n,a1,a2);
  180. _other=(T0 *)n;}
  181. _i=rT2max((C)->_lower,((T83*)_other)->_lower);
  182. _up=rT2min((C)->_upper,((T83*)_other)->_upper);
  183. while (!((_i)>(_up))) {
  184. rT83put((T83*)_other,rT83item(C,_i),_i);
  185. _i=(_i)+(1);
  186. }
  187. /*IF*/{/*AT*/free(C->_storage);
  188. }
  189. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  190. }
  191. T0 * rT83item(T83 *C,int a1){
  192. T0 * R=NULL;
  193. R=(C->_storage)[a1-(C->_lower)];
  194. return R;
  195. }
  196. void rT83add_last(T83 *C,T0 * a1){
  197. /*IF*/if (((C)->_capacity)<((rT83count(C))+(1))) {
  198. C->_capacity=((C)->_capacity)+(16);
  199. /*IF*/if (((C)->_capacity)==(16)) {
  200. C->_storage=malloc(16*sizeof(*(C->_storage)));
  201. }
  202. else {
  203. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  204. }
  205. /*FI*/}
  206. /*FI*/C->_upper=((C)->_upper)+(1);
  207. rT83put(C,a1,(C)->_upper);
  208. }
  209. void rT83put(T83 *C,T0 * a1,int a2){
  210. (C->_storage)[a2-(C->_lower)]=a1;
  211. }
  212. void rT83copy(T83 *C,T0* a1){
  213. int _i=0;
  214. C->_upper=((C)->_lower)-(1);
  215. /*IF*/if (((C)->_capacity)==(0)) {
  216. rT83make(C,((T83*)a1)->_lower,((T83*)a1)->_upper);
  217. }
  218. else {
  219. rT83resize(C,((T83*)a1)->_lower,((T83*)a1)->_upper);
  220. }
  221. /*FI*/_i=(C)->_lower;
  222. while (!((_i)>((C)->_upper))) {
  223. rT83put(C,rT83item((T83*)a1,_i),_i);
  224. _i=(_i)+(1);
  225. }
  226. }
  227. void rT83make(T83 *C,int a1,int a2){
  228. /*IF*/{/*AT*/free(C->_storage);
  229. }
  230. /*FI*/C->_lower=a1;
  231. C->_upper=a2;
  232. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  233. C->_storage=NULL;
  234. /*IF*/if (((C)->_capacity)>(0)) {
  235. C->_capacity=((C)->_capacity)+(16);
  236. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  237. rT83clear_all(C);
  238. }
  239. /*FI*/}
  240. void rT81clear_all(T81 *C){
  241. T0 * _value=NULL;
  242. rT81set_all_with(C,_value);
  243. }
  244. int rT81count(T81 *C){
  245. int R=0;
  246. R=(((C)->_upper)-((C)->_lower))+(1);
  247. return R;
  248. }
  249. void rT81set_all_with(T81 *C,T0 * a1){
  250. int _i=0;
  251. _i=(C)->_upper;
  252. while (!((_i)<((C)->_lower))) {
  253. rT81put(C,a1,_i);
  254. _i=(_i)-(1);
  255. }
  256. }
  257. void rT81resize(T81 *C,int a1,int a2){
  258. int _up=0;
  259. int _i=0;
  260. T0* _other=NULL;
  261. {T81 *n=((T81*)new(81));
  262. rT81make(n,a1,a2);
  263. _other=(T0 *)n;}
  264. _i=rT2max((C)->_lower,XrT81lower(_other));
  265. _up=rT2min((C)->_upper,XrT81upper(_other));
  266. while (!((_i)>(_up))) {
  267. XrT81put(_other,rT81item(C,_i),_i);
  268. _i=(_i)+(1);
  269. }
  270. /*IF*/{/*AT*/free(C->_storage);
  271. }
  272. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  273. }
  274. T0 * rT81item(T81 *C,int a1){
  275. T0 * R=NULL;
  276. R=(C->_storage)[a1-(C->_lower)];
  277. return R;
  278. }
  279. void rT81add_last(T81 *C,T0 * a1){
  280. /*IF*/if (((C)->_capacity)<((rT81count(C))+(1))) {
  281. C->_capacity=((C)->_capacity)+(16);
  282. /*IF*/if (((C)->_capacity)==(16)) {
  283. C->_storage=malloc(16*sizeof(*(C->_storage)));
  284. }
  285. else {
  286. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  287. }
  288. /*FI*/}
  289. /*FI*/C->_upper=((C)->_upper)+(1);
  290. rT81put(C,a1,(C)->_upper);
  291. }
  292. void rT81put(T81 *C,T0 * a1,int a2){
  293. (C->_storage)[a2-(C->_lower)]=a1;
  294. }
  295. void rT81copy(T81 *C,T0* a1){
  296. int _i=0;
  297. C->_upper=((C)->_lower)-(1);
  298. /*IF*/if (((C)->_capacity)==(0)) {
  299. rT81make(C,XrT81lower(a1),XrT81upper(a1));
  300. }
  301. else {
  302. rT81resize(C,XrT81lower(a1),XrT81upper(a1));
  303. }
  304. /*FI*/_i=(C)->_lower;
  305. while (!((_i)>((C)->_upper))) {
  306. rT81put(C,XrT81item(a1,_i),_i);
  307. _i=(_i)+(1);
  308. }
  309. }
  310. void rT81make(T81 *C,int a1,int a2){
  311. /*IF*/{/*AT*/free(C->_storage);
  312. }
  313. /*FI*/C->_lower=a1;
  314. C->_upper=a2;
  315. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  316. C->_storage=NULL;
  317. /*IF*/if (((C)->_capacity)>(0)) {
  318. C->_capacity=((C)->_capacity)+(16);
  319. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  320. rT81clear_all(C);
  321. }
  322. /*FI*/}
  323. void rT63clear_all(T63 *C){
  324. T0 * _value=NULL;
  325. rT63set_all_with(C,_value);
  326. }
  327. int rT63count(T63 *C){
  328. int R=0;
  329. R=(((C)->_upper)-((C)->_lower))+(1);
  330. return R;
  331. }
  332. void rT63set_all_with(T63 *C,T0 * a1){
  333. int _i=0;
  334. _i=(C)->_upper;
  335. while (!((_i)<((C)->_lower))) {
  336. rT63put(C,a1,_i);
  337. _i=(_i)-(1);
  338. }
  339. }
  340. void rT63resize(T63 *C,int a1,int a2){
  341. int _up=0;
  342. int _i=0;
  343. T0* _other=NULL;
  344. {T63 *n=((T63*)new(63));
  345. rT63make(n,a1,a2);
  346. _other=(T0 *)n;}
  347. _i=rT2max((C)->_lower,XrT63lower(_other));
  348. _up=rT2min((C)->_upper,XrT63upper(_other));
  349. while (!((_i)>(_up))) {
  350. XrT63put(_other,rT63item(C,_i),_i);
  351. _i=(_i)+(1);
  352. }
  353. /*IF*/{/*AT*/free(C->_storage);
  354. }
  355. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  356. }
  357. T0 * rT63item(T63 *C,int a1){
  358. T0 * R=NULL;
  359. R=(C->_storage)[a1-(C->_lower)];
  360. return R;
  361. }
  362. int rT63empty(T63 *C){
  363. int R=0;
  364. R=(rT63count(C))==(0);
  365. return R;
  366. }
  367. void rT63add_last(T63 *C,T0 * a1){
  368. /*IF*/if (((C)->_capacity)<((rT63count(C))+(1))) {
  369. C->_capacity=((C)->_capacity)+(16);
  370. /*IF*/if (((C)->_capacity)==(16)) {
  371. C->_storage=malloc(16*sizeof(*(C->_storage)));
  372. }
  373. else {
  374. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  375. }
  376. /*FI*/}
  377. /*FI*/C->_upper=((C)->_upper)+(1);
  378. rT63put(C,a1,(C)->_upper);
  379. }
  380. void rT63put(T63 *C,T0 * a1,int a2){
  381. (C->_storage)[a2-(C->_lower)]=a1;
  382. }
  383. void rT63copy(T63 *C,T0* a1){
  384. int _i=0;
  385. C->_upper=((C)->_lower)-(1);
  386. /*IF*/if (((C)->_capacity)==(0)) {
  387. rT63make(C,XrT63lower(a1),XrT63upper(a1));
  388. }
  389. else {
  390. rT63resize(C,XrT63lower(a1),XrT63upper(a1));
  391. }
  392. /*FI*/_i=(C)->_lower;
  393. while (!((_i)>((C)->_upper))) {
  394. rT63put(C,XrT63item(a1,_i),_i);
  395. _i=(_i)+(1);
  396. }
  397. }
  398. void rT63make(T63 *C,int a1,int a2){
  399. /*IF*/{/*AT*/free(C->_storage);
  400. }
  401. /*FI*/C->_lower=a1;
  402. C->_upper=a2;
  403. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  404. C->_storage=NULL;
  405. /*IF*/if (((C)->_capacity)>(0)) {
  406. C->_capacity=((C)->_capacity)+(16);
  407. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  408. rT63clear_all(C);
  409. }
  410. /*FI*/}
  411. void rT56clear(T56 *C){
  412. C->_upper=((C)->_lower)-(1);
  413. }
  414. void rT56clear_all(T56 *C){
  415. T0 * _value=NULL;
  416. rT56set_all_with(C,_value);
  417. }
  418. T0 * rT56first(T56 *C){
  419. T0 * R=NULL;
  420. R=rT56item(C,(C)->_lower);
  421. return R;
  422. }
  423. int rT56count(T56 *C){
  424. int R=0;
  425. R=(((C)->_upper)-((C)->_lower))+(1);
  426. return R;
  427. }
  428. void rT56set_all_with(T56 *C,T0 * a1){
  429. int _i=0;
  430. _i=(C)->_upper;
  431. while (!((_i)<((C)->_lower))) {
  432. rT56put(C,a1,_i);
  433. _i=(_i)-(1);
  434. }
  435. }
  436. int rT56fast_index_of(T56 *C,T0 * a1){
  437. int R=0;
  438. R=(C)->_lower;
  439. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT56item(C,R))))) {
  440. R=(R)+(1);
  441. }
  442. return R;
  443. }
  444. int rT56fast_has(T56 *C,T0 * a1){
  445. int R=0;
  446. R=(rT56fast_index_of(C,a1))!=(((C)->_upper)+(1));
  447. return R;
  448. }
  449. void rT56resize(T56 *C,int a1,int a2){
  450. int _up=0;
  451. int _i=0;
  452. T0* _other=NULL;
  453. {T56 *n=((T56*)new(56));
  454. rT56make(n,a1,a2);
  455. _other=(T0 *)n;}
  456. _i=rT2max((C)->_lower,((T56*)_other)->_lower);
  457. _up=rT2min((C)->_upper,((T56*)_other)->_upper);
  458. while (!((_i)>(_up))) {
  459. rT56put((T56*)_other,rT56item(C,_i),_i);
  460. _i=(_i)+(1);
  461. }
  462. /*IF*/{/*AT*/free(C->_storage);
  463. }
  464. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  465. }
  466. T0 * rT56item(T56 *C,int a1){
  467. T0 * R=NULL;
  468. R=(C->_storage)[a1-(C->_lower)];
  469. return R;
  470. }
  471. void rT56add_last(T56 *C,T0 * a1){
  472. /*IF*/if (((C)->_capacity)<((rT56count(C))+(1))) {
  473. C->_capacity=((C)->_capacity)+(16);
  474. /*IF*/if (((C)->_capacity)==(16)) {
  475. C->_storage=malloc(16*sizeof(*(C->_storage)));
  476. }
  477. else {
  478. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  479. }
  480. /*FI*/}
  481. /*FI*/C->_upper=((C)->_upper)+(1);
  482. rT56put(C,a1,(C)->_upper);
  483. }
  484. void rT56put(T56 *C,T0 * a1,int a2){
  485. (C->_storage)[a2-(C->_lower)]=a1;
  486. }
  487. void rT56copy(T56 *C,T0* a1){
  488. int _i=0;
  489. C->_upper=((C)->_lower)-(1);
  490. /*IF*/if (((C)->_capacity)==(0)) {
  491. rT56make(C,((T56*)a1)->_lower,((T56*)a1)->_upper);
  492. }
  493. else {
  494. rT56resize(C,((T56*)a1)->_lower,((T56*)a1)->_upper);
  495. }
  496. /*FI*/_i=(C)->_lower;
  497. while (!((_i)>((C)->_upper))) {
  498. rT56put(C,rT56item((T56*)a1,_i),_i);
  499. _i=(_i)+(1);
  500. }
  501. }
  502. void rT56make(T56 *C,int a1,int a2){
  503. /*IF*/{/*AT*/free(C->_storage);
  504. }
  505. /*FI*/C->_lower=a1;
  506. C->_upper=a2;
  507. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  508. C->_storage=NULL;
  509. /*IF*/if (((C)->_capacity)>(0)) {
  510. C->_capacity=((C)->_capacity)+(16);
  511. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  512. rT56clear_all(C);
  513. }
  514. /*FI*/}
  515. void rT55clear_all(T55 *C){
  516. int _value=0;
  517. rT55set_all_with(C,_value);
  518. }
  519. int rT55count(T55 *C){
  520. int R=0;
  521. R=(((C)->_upper)-((C)->_lower))+(1);
  522. return R;
  523. }
  524. void rT55set_all_with(T55 *C,int a1){
  525. int _i=0;
  526. _i=(C)->_upper;
  527. while (!((_i)<((C)->_lower))) {
  528. rT55put(C,a1,_i);
  529. _i=(_i)-(1);
  530. }
  531. }
  532. void rT55resize(T55 *C,int a1,int a2){
  533. int _up=0;
  534. int _i=0;
  535. T0* _other=NULL;
  536. {T55 *n=((T55*)new(55));
  537. rT55make(n,a1,a2);
  538. _other=(T0 *)n;}
  539. _i=rT2max((C)->_lower,((T55*)_other)->_lower);
  540. _up=rT2min((C)->_upper,((T55*)_other)->_upper);
  541. while (!((_i)>(_up))) {
  542. rT55put((T55*)_other,rT55item(C,_i),_i);
  543. _i=(_i)+(1);
  544. }
  545. /*IF*/{/*AT*/free(C->_storage);
  546. }
  547. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  548. }
  549. int rT55item(T55 *C,int a1){
  550. int R=0;
  551. R=(C->_storage)[a1-(C->_lower)];
  552. return R;
  553. }
  554. void rT55add_last(T55 *C,int a1){
  555. /*IF*/if (((C)->_capacity)<((rT55count(C))+(1))) {
  556. C->_capacity=((C)->_capacity)+(16);
  557. /*IF*/if (((C)->_capacity)==(16)) {
  558. C->_storage=malloc(16*sizeof(*(C->_storage)));
  559. }
  560. else {
  561. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  562. }
  563. /*FI*/}
  564. /*FI*/C->_upper=((C)->_upper)+(1);
  565. rT55put(C,a1,(C)->_upper);
  566. }
  567. void rT55put(T55 *C,int a1,int a2){
  568. (C->_storage)[a2-(C->_lower)]=a1;
  569. }
  570. void rT55copy(T55 *C,T0* a1){
  571. int _i=0;
  572. C->_upper=((C)->_lower)-(1);
  573. /*IF*/if (((C)->_capacity)==(0)) {
  574. rT55make(C,((T55*)a1)->_lower,((T55*)a1)->_upper);
  575. }
  576. else {
  577. rT55resize(C,((T55*)a1)->_lower,((T55*)a1)->_upper);
  578. }
  579. /*FI*/_i=(C)->_lower;
  580. while (!((_i)>((C)->_upper))) {
  581. rT55put(C,rT55item((T55*)a1,_i),_i);
  582. _i=(_i)+(1);
  583. }
  584. }
  585. void rT55make(T55 *C,int a1,int a2){
  586. /*IF*/{/*AT*/free(C->_storage);
  587. }
  588. /*FI*/C->_lower=a1;
  589. C->_upper=a2;
  590. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  591. C->_storage=NULL;
  592. /*IF*/if (((C)->_capacity)>(0)) {
  593. C->_capacity=((C)->_capacity)+(16);
  594. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  595. rT55clear_all(C);
  596. }
  597. /*FI*/}
  598. void rT47clear(T47 *C){
  599. C->_upper=((C)->_lower)-(1);
  600. }
  601. void rT47clear_all(T47 *C){
  602. T0 * _value=NULL;
  603. rT47set_all_with(C,_value);
  604. }
  605. int rT47count(T47 *C){
  606. int R=0;
  607. R=(((C)->_upper)-((C)->_lower))+(1);
  608. return R;
  609. }
  610. void rT47set_all_with(T47 *C,T0 * a1){
  611. int _i=0;
  612. _i=(C)->_upper;
  613. while (!((_i)<((C)->_lower))) {
  614. rT47put(C,a1,_i);
  615. _i=(_i)-(1);
  616. }
  617. }
  618. void rT47resize(T47 *C,int a1,int a2){
  619. int _up=0;
  620. int _i=0;
  621. T0* _other=NULL;
  622. {T47 *n=((T47*)new(47));
  623. rT47make(n,a1,a2);
  624. _other=(T0 *)n;}
  625. _i=rT2max((C)->_lower,((T47*)_other)->_lower);
  626. _up=rT2min((C)->_upper,((T47*)_other)->_upper);
  627. while (!((_i)>(_up))) {
  628. rT47put((T47*)_other,rT47item(C,_i),_i);
  629. _i=(_i)+(1);
  630. }
  631. /*IF*/{/*AT*/free(C->_storage);
  632. }
  633. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  634. }
  635. int rT47empty(T47 *C){
  636. int R=0;
  637. R=(rT47count(C))==(0);
  638. return R;
  639. }
  640. T0 * rT47item(T47 *C,int a1){
  641. T0 * R=NULL;
  642. R=(C->_storage)[a1-(C->_lower)];
  643. return R;
  644. }
  645. void rT47add_last(T47 *C,T0 * a1){
  646. /*IF*/if (((C)->_capacity)<((rT47count(C))+(1))) {
  647. C->_capacity=((C)->_capacity)+(16);
  648. /*IF*/if (((C)->_capacity)==(16)) {
  649. C->_storage=malloc(16*sizeof(*(C->_storage)));
  650. }
  651. else {
  652. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  653. }
  654. /*FI*/}
  655. /*FI*/C->_upper=((C)->_upper)+(1);
  656. rT47put(C,a1,(C)->_upper);
  657. }
  658. int rT47equal_like(/*C*/T0 * a1,T0 * a2){
  659. int R=0;
  660. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  661. R=1;
  662. }
  663.  else if ((!(a1))||(!(a2))) {
  664. }
  665. else {
  666. R=rT46is_equal((T46*)a1,a2);
  667. }
  668. /*FI*/return R;
  669. }
  670. int rT47index_of(T47 *C,T0 * a1){
  671. int R=0;
  672. R=(C)->_lower;
  673. while (!(((R)>((C)->_upper))||(rT47equal_like(a1,rT47item(C,R))))) {
  674. R=(R)+(1);
  675. }
  676. return R;
  677. }
  678. void rT47put(T47 *C,T0 * a1,int a2){
  679. (C->_storage)[a2-(C->_lower)]=a1;
  680. }
  681. void rT47copy(T47 *C,T0* a1){
  682. int _i=0;
  683. C->_upper=((C)->_lower)-(1);
  684. /*IF*/if (((C)->_capacity)==(0)) {
  685. rT47make(C,((T47*)a1)->_lower,((T47*)a1)->_upper);
  686. }
  687. else {
  688. rT47resize(C,((T47*)a1)->_lower,((T47*)a1)->_upper);
  689. }
  690. /*FI*/_i=(C)->_lower;
  691. while (!((_i)>((C)->_upper))) {
  692. rT47put(C,rT47item((T47*)a1,_i),_i);
  693. _i=(_i)+(1);
  694. }
  695. }
  696. int rT47has(T47 *C,T0 * a1){
  697. int R=0;
  698. R=(rT47index_of(C,a1))!=(((C)->_upper)+(1));
  699. return R;
  700. }
  701. void rT47make(T47 *C,int a1,int a2){
  702. /*IF*/{/*AT*/free(C->_storage);
  703. }
  704. /*FI*/C->_lower=a1;
  705. C->_upper=a2;
  706. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  707. C->_storage=NULL;
  708. /*IF*/if (((C)->_capacity)>(0)) {
  709. C->_capacity=((C)->_capacity)+(16);
  710. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  711. rT47clear_all(C);
  712. }
  713. /*FI*/}
  714. void rT41clear(T41 *C){
  715. C->_upper=((C)->_lower)-(1);
  716. }
  717. void rT41clear_all(T41 *C){
  718. T0* _value=NULL;
  719. rT41set_all_with(C,_value);
  720. }
  721. int rT41count(T41 *C){
  722. int R=0;
  723. R=(((C)->_upper)-((C)->_lower))+(1);
  724. return R;
  725. }
  726. void rT41add(T41 *C,T0* a1){
  727. /*IF*/if (!(rT41has(C,a1))) {
  728. rT41add_last(C,a1);
  729. }
  730. /*FI*/}
  731. void rT41set_all_with(T41 *C,T0* a1){
  732. int _i=0;
  733. _i=(C)->_upper;
  734. while (!((_i)<((C)->_lower))) {
  735. rT41put(C,a1,_i);
  736. _i=(_i)-(1);
  737. }
  738. }
  739. int rT41fast_index_of(T41 *C,T0* a1){
  740. int R=0;
  741. R=(C)->_lower;
  742. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT41item(C,R))))) {
  743. R=(R)+(1);
  744. }
  745. return R;
  746. }
  747. int rT41fast_has(T41 *C,T0* a1){
  748. int R=0;
  749. R=(rT41fast_index_of(C,a1))!=(((C)->_upper)+(1));
  750. return R;
  751. }
  752. void rT41resize(T41 *C,int a1,int a2){
  753. int _up=0;
  754. int _i=0;
  755. T0* _other=NULL;
  756. {T41 *n=((T41*)new(41));
  757. rT41make(n,a1,a2);
  758. _other=(T0 *)n;}
  759. _i=rT2max((C)->_lower,((T41*)_other)->_lower);
  760. _up=rT2min((C)->_upper,((T41*)_other)->_upper);
  761. while (!((_i)>(_up))) {
  762. rT41put((T41*)_other,rT41item(C,_i),_i);
  763. _i=(_i)+(1);
  764. }
  765. /*IF*/{/*AT*/free(C->_storage);
  766. }
  767. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  768. }
  769. T0* rT41item(T41 *C,int a1){
  770. T0* R=NULL;
  771. R=(C->_storage)[a1-(C->_lower)];
  772. return R;
  773. }
  774. void rT41add_last(T41 *C,T0* a1){
  775. /*IF*/if (((C)->_capacity)<((rT41count(C))+(1))) {
  776. C->_capacity=((C)->_capacity)+(16);
  777. /*IF*/if (((C)->_capacity)==(16)) {
  778. C->_storage=malloc(16*sizeof(*(C->_storage)));
  779. }
  780. else {
  781. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  782. }
  783. /*FI*/}
  784. /*FI*/C->_upper=((C)->_upper)+(1);
  785. rT41put(C,a1,(C)->_upper);
  786. }
  787. int rT41equal_like(/*C*/T0* a1,T0* a2){
  788. int R=0;
  789. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  790. R=1;
  791. }
  792.  else if ((!(a1))||(!(a2))) {
  793. }
  794. else {
  795. R=rT7is_equal((T7*)a1,a2);
  796. }
  797. /*FI*/return R;
  798. }
  799. int rT41index_of(T41 *C,T0* a1){
  800. int R=0;
  801. R=(C)->_lower;
  802. while (!(((R)>((C)->_upper))||(rT41equal_like(a1,rT41item(C,R))))) {
  803. R=(R)+(1);
  804. }
  805. return R;
  806. }
  807. void rT41put(T41 *C,T0* a1,int a2){
  808. (C->_storage)[a2-(C->_lower)]=a1;
  809. }
  810. void rT41copy(T41 *C,T0* a1){
  811. int _i=0;
  812. C->_upper=((C)->_lower)-(1);
  813. /*IF*/if (((C)->_capacity)==(0)) {
  814. rT41make(C,((T41*)a1)->_lower,((T41*)a1)->_upper);
  815. }
  816. else {
  817. rT41resize(C,((T41*)a1)->_lower,((T41*)a1)->_upper);
  818. }
  819. /*FI*/_i=(C)->_lower;
  820. while (!((_i)>((C)->_upper))) {
  821. rT41put(C,rT41item((T41*)a1,_i),_i);
  822. _i=(_i)+(1);
  823. }
  824. }
  825. int rT41has(T41 *C,T0* a1){
  826. int R=0;
  827. R=(rT41index_of(C,a1))!=(((C)->_upper)+(1));
  828. return R;
  829. }
  830. void rT41make(T41 *C,int a1,int a2){
  831. /*IF*/{/*AT*/free(C->_storage);
  832. }
  833. /*FI*/C->_lower=a1;
  834. C->_upper=a2;
  835. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  836. C->_storage=NULL;
  837. /*IF*/if (((C)->_capacity)>(0)) {
  838. C->_capacity=((C)->_capacity)+(16);
  839. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  840. rT41clear_all(C);
  841. }
  842. /*FI*/}
  843. void rT106clear_all(T106 *C){
  844. T0 * _value=NULL;
  845. rT106set_all_with(C,_value);
  846. }
  847. T0 * rT106first(T106 *C){
  848. T0 * R=NULL;
  849. R=rT106item(C,(C)->_lower);
  850. return R;
  851. }
  852. int rT106count(T106 *C){
  853. int R=0;
  854. R=(((C)->_upper)-((C)->_lower))+(1);
  855. return R;
  856. }
  857. void rT106set_all_with(T106 *C,T0 * a1){
  858. int _i=0;
  859. _i=(C)->_upper;
  860. while (!((_i)<((C)->_lower))) {
  861. rT106put(C,a1,_i);
  862. _i=(_i)-(1);
  863. }
  864. }
  865. void rT106resize(T106 *C,int a1,int a2){
  866. int _up=0;
  867. int _i=0;
  868. T0* _other=NULL;
  869. {T106 *n=((T106*)new(106));
  870. rT106make(n,a1,a2);
  871. _other=(T0 *)n;}
  872. _i=rT2max((C)->_lower,((T106*)_other)->_lower);
  873. _up=rT2min((C)->_upper,((T106*)_other)->_upper);
  874. while (!((_i)>(_up))) {
  875. rT106put((T106*)_other,rT106item(C,_i),_i);
  876. _i=(_i)+(1);
  877. }
  878. /*IF*/{/*AT*/free(C->_storage);
  879. }
  880. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  881. }
  882. T0 * rT106item(T106 *C,int a1){
  883. T0 * R=NULL;
  884. R=(C->_storage)[a1-(C->_lower)];
  885. return R;
  886. }
  887. void rT106add_last(T106 *C,T0 * a1){
  888. /*IF*/if (((C)->_capacity)<((rT106count(C))+(1))) {
  889. C->_capacity=((C)->_capacity)+(16);
  890. /*IF*/if (((C)->_capacity)==(16)) {
  891. C->_storage=malloc(16*sizeof(*(C->_storage)));
  892. }
  893. else {
  894. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  895. }
  896. /*FI*/}
  897. /*FI*/C->_upper=((C)->_upper)+(1);
  898. rT106put(C,a1,(C)->_upper);
  899. }
  900. void rT106put(T106 *C,T0 * a1,int a2){
  901. (C->_storage)[a2-(C->_lower)]=a1;
  902. }
  903. void rT106copy(T106 *C,T0* a1){
  904. int _i=0;
  905. C->_upper=((C)->_lower)-(1);
  906. /*IF*/if (((C)->_capacity)==(0)) {
  907. rT106make(C,((T106*)a1)->_lower,((T106*)a1)->_upper);
  908. }
  909. else {
  910. rT106resize(C,((T106*)a1)->_lower,((T106*)a1)->_upper);
  911. }
  912. /*FI*/_i=(C)->_lower;
  913. while (!((_i)>((C)->_upper))) {
  914. rT106put(C,rT106item((T106*)a1,_i),_i);
  915. _i=(_i)+(1);
  916. }
  917. }
  918. void rT106make(T106 *C,int a1,int a2){
  919. /*IF*/{/*AT*/free(C->_storage);
  920. }
  921. /*FI*/C->_lower=a1;
  922. C->_upper=a2;
  923. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  924. C->_storage=NULL;
  925. /*IF*/if (((C)->_capacity)>(0)) {
  926. C->_capacity=((C)->_capacity)+(16);
  927. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  928. rT106clear_all(C);
  929. }
  930. /*FI*/}
  931. void rT121clear_all(T121 *C){
  932. T0 * _value=NULL;
  933. rT121set_all_with(C,_value);
  934. }
  935. int rT121count(T121 *C){
  936. int R=0;
  937. R=(((C)->_upper)-((C)->_lower))+(1);
  938. return R;
  939. }
  940. void rT121set_all_with(T121 *C,T0 * a1){
  941. int _i=0;
  942. _i=(C)->_upper;
  943. while (!((_i)<((C)->_lower))) {
  944. rT121put(C,a1,_i);
  945. _i=(_i)-(1);
  946. }
  947. }
  948. void rT121resize(T121 *C,int a1,int a2){
  949. int _up=0;
  950. int _i=0;
  951. T0* _other=NULL;
  952. {T121 *n=((T121*)new(121));
  953. rT121make(n,a1,a2);
  954. _other=(T0 *)n;}
  955. _i=rT2max((C)->_lower,((T121*)_other)->_lower);
  956. _up=rT2min((C)->_upper,((T121*)_other)->_upper);
  957. while (!((_i)>(_up))) {
  958. rT121put((T121*)_other,rT121item(C,_i),_i);
  959. _i=(_i)+(1);
  960. }
  961. /*IF*/{/*AT*/free(C->_storage);
  962. }
  963. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  964. }
  965. T0 * rT121item(T121 *C,int a1){
  966. T0 * R=NULL;
  967. R=(C->_storage)[a1-(C->_lower)];
  968. return R;
  969. }
  970. void rT121add_last(T121 *C,T0 * a1){
  971. /*IF*/if (((C)->_capacity)<((rT121count(C))+(1))) {
  972. C->_capacity=((C)->_capacity)+(16);
  973. /*IF*/if (((C)->_capacity)==(16)) {
  974. C->_storage=malloc(16*sizeof(*(C->_storage)));
  975. }
  976. else {
  977. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  978. }
  979. /*FI*/}
  980. /*FI*/C->_upper=((C)->_upper)+(1);
  981. rT121put(C,a1,(C)->_upper);
  982. }
  983. void rT121put(T121 *C,T0 * a1,int a2){
  984. (C->_storage)[a2-(C->_lower)]=a1;
  985. }
  986. void rT121copy(T121 *C,T0* a1){
  987. int _i=0;
  988. C->_upper=((C)->_lower)-(1);
  989. /*IF*/if (((C)->_capacity)==(0)) {
  990. rT121make(C,((T121*)a1)->_lower,((T121*)a1)->_upper);
  991. }
  992. else {
  993. rT121resize(C,((T121*)a1)->_lower,((T121*)a1)->_upper);
  994. }
  995. /*FI*/_i=(C)->_lower;
  996. while (!((_i)>((C)->_upper))) {
  997. rT121put(C,rT121item((T121*)a1,_i),_i);
  998. _i=(_i)+(1);
  999. }
  1000. }
  1001. void rT121make(T121 *C,int a1,int a2){
  1002. /*IF*/{/*AT*/free(C->_storage);
  1003. }
  1004. /*FI*/C->_lower=a1;
  1005. C->_upper=a2;
  1006. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1007. C->_storage=NULL;
  1008. /*IF*/if (((C)->_capacity)>(0)) {
  1009. C->_capacity=((C)->_capacity)+(16);
  1010. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1011. rT121clear_all(C);
  1012. }
  1013. /*FI*/}
  1014. void rT125clear_all(T125 *C){
  1015. T0 * _value=NULL;
  1016. rT125set_all_with(C,_value);
  1017. }
  1018. int rT125count(T125 *C){
  1019. int R=0;
  1020. R=(((C)->_upper)-((C)->_lower))+(1);
  1021. return R;
  1022. }
  1023. void rT125set_all_with(T125 *C,T0 * a1){
  1024. int _i=0;
  1025. _i=(C)->_upper;
  1026. while (!((_i)<((C)->_lower))) {
  1027. rT125put(C,a1,_i);
  1028. _i=(_i)-(1);
  1029. }
  1030. }
  1031. void rT125resize(T125 *C,int a1,int a2){
  1032. int _up=0;
  1033. int _i=0;
  1034. T0* _other=NULL;
  1035. {T125 *n=((T125*)new(125));
  1036. rT125make(n,a1,a2);
  1037. _other=(T0 *)n;}
  1038. _i=rT2max((C)->_lower,((T125*)_other)->_lower);
  1039. _up=rT2min((C)->_upper,((T125*)_other)->_upper);
  1040. while (!((_i)>(_up))) {
  1041. rT125put((T125*)_other,rT125item(C,_i),_i);
  1042. _i=(_i)+(1);
  1043. }
  1044. /*IF*/{/*AT*/free(C->_storage);
  1045. }
  1046. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1047. }
  1048. T0 * rT125item(T125 *C,int a1){
  1049. T0 * R=NULL;
  1050. R=(C->_storage)[a1-(C->_lower)];
  1051. return R;
  1052. }
  1053. void rT125add_last(T125 *C,T0 * a1){
  1054. /*IF*/if (((C)->_capacity)<((rT125count(C))+(1))) {
  1055. C->_capacity=((C)->_capacity)+(16);
  1056. /*IF*/if (((C)->_capacity)==(16)) {
  1057. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1058. }
  1059. else {
  1060. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1061. }
  1062. /*FI*/}
  1063. /*FI*/C->_upper=((C)->_upper)+(1);
  1064. rT125put(C,a1,(C)->_upper);
  1065. }
  1066. void rT125put(T125 *C,T0 * a1,int a2){
  1067. (C->_storage)[a2-(C->_lower)]=a1;
  1068. }
  1069. void rT125copy(T125 *C,T0* a1){
  1070. int _i=0;
  1071. C->_upper=((C)->_lower)-(1);
  1072. /*IF*/if (((C)->_capacity)==(0)) {
  1073. rT125make(C,((T125*)a1)->_lower,((T125*)a1)->_upper);
  1074. }
  1075. else {
  1076. rT125resize(C,((T125*)a1)->_lower,((T125*)a1)->_upper);
  1077. }
  1078. /*FI*/_i=(C)->_lower;
  1079. while (!((_i)>((C)->_upper))) {
  1080. rT125put(C,rT125item((T125*)a1,_i),_i);
  1081. _i=(_i)+(1);
  1082. }
  1083. }
  1084. void rT125make(T125 *C,int a1,int a2){
  1085. /*IF*/{/*AT*/free(C->_storage);
  1086. }
  1087. /*FI*/C->_lower=a1;
  1088. C->_upper=a2;
  1089. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1090. C->_storage=NULL;
  1091. /*IF*/if (((C)->_capacity)>(0)) {
  1092. C->_capacity=((C)->_capacity)+(16);
  1093. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1094. rT125clear_all(C);
  1095. }
  1096. /*FI*/}
  1097. void rT127clear_all(T127 *C){
  1098. T0 * _value=NULL;
  1099. rT127set_all_with(C,_value);
  1100. }
  1101. int rT127count(T127 *C){
  1102. int R=0;
  1103. R=(((C)->_upper)-((C)->_lower))+(1);
  1104. return R;
  1105. }
  1106. void rT127set_all_with(T127 *C,T0 * a1){
  1107. int _i=0;
  1108. _i=(C)->_upper;
  1109. while (!((_i)<((C)->_lower))) {
  1110. rT127put(C,a1,_i);
  1111. _i=(_i)-(1);
  1112. }
  1113. }
  1114. void rT127resize(T127 *C,int a1,int a2){
  1115. int _up=0;
  1116. int _i=0;
  1117. T0* _other=NULL;
  1118. {T127 *n=((T127*)new(127));
  1119. rT127make(n,a1,a2);
  1120. _other=(T0 *)n;}
  1121. _i=rT2max((C)->_lower,((T127*)_other)->_lower);
  1122. _up=rT2min((C)->_upper,((T127*)_other)->_upper);
  1123. while (!((_i)>(_up))) {
  1124. rT127put((T127*)_other,rT127item(C,_i),_i);
  1125. _i=(_i)+(1);
  1126. }
  1127. /*IF*/{/*AT*/free(C->_storage);
  1128. }
  1129. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1130. }
  1131. T0 * rT127item(T127 *C,int a1){
  1132. T0 * R=NULL;
  1133. R=(C->_storage)[a1-(C->_lower)];
  1134. return R;
  1135. }
  1136. void rT127add_last(T127 *C,T0 * a1){
  1137. /*IF*/if (((C)->_capacity)<((rT127count(C))+(1))) {
  1138. C->_capacity=((C)->_capacity)+(16);
  1139. /*IF*/if (((C)->_capacity)==(16)) {
  1140. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1141. }
  1142. else {
  1143. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1144. }
  1145. /*FI*/}
  1146. /*FI*/C->_upper=((C)->_upper)+(1);
  1147. rT127put(C,a1,(C)->_upper);
  1148. }
  1149. void rT127put(T127 *C,T0 * a1,int a2){
  1150. (C->_storage)[a2-(C->_lower)]=a1;
  1151. }
  1152. void rT127copy(T127 *C,T0* a1){
  1153. int _i=0;
  1154. C->_upper=((C)->_lower)-(1);
  1155. /*IF*/if (((C)->_capacity)==(0)) {
  1156. rT127make(C,((T127*)a1)->_lower,((T127*)a1)->_upper);
  1157. }
  1158. else {
  1159. rT127resize(C,((T127*)a1)->_lower,((T127*)a1)->_upper);
  1160. }
  1161. /*FI*/_i=(C)->_lower;
  1162. while (!((_i)>((C)->_upper))) {
  1163. rT127put(C,rT127item((T127*)a1,_i),_i);
  1164. _i=(_i)+(1);
  1165. }
  1166. }
  1167. void rT127make(T127 *C,int a1,int a2){
  1168. /*IF*/{/*AT*/free(C->_storage);
  1169. }
  1170. /*FI*/C->_lower=a1;
  1171. C->_upper=a2;
  1172. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1173. C->_storage=NULL;
  1174. /*IF*/if (((C)->_capacity)>(0)) {
  1175. C->_capacity=((C)->_capacity)+(16);
  1176. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1177. rT127clear_all(C);
  1178. }
  1179. /*FI*/}
  1180. void rT129clear(T129 *C){
  1181. C->_upper=((C)->_lower)-(1);
  1182. }
  1183. void rT129clear_all(T129 *C){
  1184. T0 * _value=NULL;
  1185. rT129set_all_with(C,_value);
  1186. }
  1187. T0 * rT129first(T129 *C){
  1188. T0 * R=NULL;
  1189. R=rT129item(C,(C)->_lower);
  1190. return R;
  1191. }
  1192. int rT129count(T129 *C){
  1193. int R=0;
  1194. R=(((C)->_upper)-((C)->_lower))+(1);
  1195. return R;
  1196. }
  1197. void rT129set_all_with(T129 *C,T0 * a1){
  1198. int _i=0;
  1199. _i=(C)->_upper;
  1200. while (!((_i)<((C)->_lower))) {
  1201. rT129put(C,a1,_i);
  1202. _i=(_i)-(1);
  1203. }
  1204. }
  1205. void rT129resize(T129 *C,int a1,int a2){
  1206. int _up=0;
  1207. int _i=0;
  1208. T0* _other=NULL;
  1209. {T129 *n=((T129*)new(129));
  1210. rT129make(n,a1,a2);
  1211. _other=(T0 *)n;}
  1212. _i=rT2max((C)->_lower,((T129*)_other)->_lower);
  1213. _up=rT2min((C)->_upper,((T129*)_other)->_upper);
  1214. while (!((_i)>(_up))) {
  1215. rT129put((T129*)_other,rT129item(C,_i),_i);
  1216. _i=(_i)+(1);
  1217. }
  1218. /*IF*/{/*AT*/free(C->_storage);
  1219. }
  1220. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1221. }
  1222. T0 * rT129item(T129 *C,int a1){
  1223. T0 * R=NULL;
  1224. R=(C->_storage)[a1-(C->_lower)];
  1225. return R;
  1226. }
  1227. void rT129add_last(T129 *C,T0 * a1){
  1228. /*IF*/if (((C)->_capacity)<((rT129count(C))+(1))) {
  1229. C->_capacity=((C)->_capacity)+(16);
  1230. /*IF*/if (((C)->_capacity)==(16)) {
  1231. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1232. }
  1233. else {
  1234. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1235. }
  1236. /*FI*/}
  1237. /*FI*/C->_upper=((C)->_upper)+(1);
  1238. rT129put(C,a1,(C)->_upper);
  1239. }
  1240. void rT129put(T129 *C,T0 * a1,int a2){
  1241. (C->_storage)[a2-(C->_lower)]=a1;
  1242. }
  1243. void rT129copy(T129 *C,T0* a1){
  1244. int _i=0;
  1245. C->_upper=((C)->_lower)-(1);
  1246. /*IF*/if (((C)->_capacity)==(0)) {
  1247. rT129make(C,((T129*)a1)->_lower,((T129*)a1)->_upper);
  1248. }
  1249. else {
  1250. rT129resize(C,((T129*)a1)->_lower,((T129*)a1)->_upper);
  1251. }
  1252. /*FI*/_i=(C)->_lower;
  1253. while (!((_i)>((C)->_upper))) {
  1254. rT129put(C,rT129item((T129*)a1,_i),_i);
  1255. _i=(_i)+(1);
  1256. }
  1257. }
  1258. void rT129make(T129 *C,int a1,int a2){
  1259. /*IF*/{/*AT*/free(C->_storage);
  1260. }
  1261. /*FI*/C->_lower=a1;
  1262. C->_upper=a2;
  1263. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1264. C->_storage=NULL;
  1265. /*IF*/if (((C)->_capacity)>(0)) {
  1266. C->_capacity=((C)->_capacity)+(16);
  1267. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1268. rT129clear_all(C);
  1269. }
  1270. /*FI*/}
  1271. void rT130clear_all(T130 *C){
  1272. T0 * _value=NULL;
  1273. rT130set_all_with(C,_value);
  1274. }
  1275. T0 * rT130first(T130 *C){
  1276. T0 * R=NULL;
  1277. R=rT130item(C,(C)->_lower);
  1278. return R;
  1279. }
  1280. int rT130count(T130 *C){
  1281. int R=0;
  1282. R=(((C)->_upper)-((C)->_lower))+(1);
  1283. return R;
  1284. }
  1285. void rT130set_all_with(T130 *C,T0 * a1){
  1286. int _i=0;
  1287. _i=(C)->_upper;
  1288. while (!((_i)<((C)->_lower))) {
  1289. rT130put(C,a1,_i);
  1290. _i=(_i)-(1);
  1291. }
  1292. }
  1293. void rT130resize(T130 *C,int a1,int a2){
  1294. int _up=0;
  1295. int _i=0;
  1296. T0* _other=NULL;
  1297. {T130 *n=((T130*)new(130));
  1298. rT130make(n,a1,a2);
  1299. _other=(T0 *)n;}
  1300. _i=rT2max((C)->_lower,((T130*)_other)->_lower);
  1301. _up=rT2min((C)->_upper,((T130*)_other)->_upper);
  1302. while (!((_i)>(_up))) {
  1303. rT130put((T130*)_other,rT130item(C,_i),_i);
  1304. _i=(_i)+(1);
  1305. }
  1306. /*IF*/{/*AT*/free(C->_storage);
  1307. }
  1308. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1309. }
  1310. T0 * rT130item(T130 *C,int a1){
  1311. T0 * R=NULL;
  1312. R=(C->_storage)[a1-(C->_lower)];
  1313. return R;
  1314. }
  1315. void rT130add_last(T130 *C,T0 * a1){
  1316. /*IF*/if (((C)->_capacity)<((rT130count(C))+(1))) {
  1317. C->_capacity=((C)->_capacity)+(16);
  1318. /*IF*/if (((C)->_capacity)==(16)) {
  1319. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1320. }
  1321. else {
  1322. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1323. }
  1324. /*FI*/}
  1325. /*FI*/C->_upper=((C)->_upper)+(1);
  1326. rT130put(C,a1,(C)->_upper);
  1327. }
  1328. void rT130put(T130 *C,T0 * a1,int a2){
  1329. (C->_storage)[a2-(C->_lower)]=a1;
  1330. }
  1331.